#include "b16.h"

/* Toma la entrada y mientras lo va procesando y convirtiendo a hexa lo va
 * escribiendo en la salida
 */
void binary_to_hexa(FILE* archivoEntrada, FILE* archivoSalida) {

	int fd_archivo_entrada = fileno(archivoEntrada);
	int fd_archivo_salida = fileno(archivoSalida);

	int error_encode = encode(fd_archivo_entrada, fd_archivo_salida);

	const char* salida_encode = b16_errmsg[error_encode];

	fprintf(stderr, "%s\n", salida_encode);

}

void hexa_to_binary(FILE* archivoEntrada, FILE* archivoSalida)
{

		int fd_archivo_entrada = fileno(archivoEntrada);
		int fd_archivo_salida = fileno(archivoSalida);


		int error_decode = decode(fd_archivo_entrada, fd_archivo_salida);

		const char* salida_decode = b16_errmsg[error_decode];

		fprintf(stderr, "%s\n", salida_decode);

}

int Help_Option() {
	FILE* help = NULL;
	char buffer[50];
	help = fopen("help.txt", "r");
	while (!feof(help)) {
		int err = fread(buffer, 1, 50, help);
		if (err != 0) {
			printf("%s", buffer);
			strcpy(buffer, "");
		}
	}
	fclose(help);
	return NO_PROCESAR;
}

void Init(char** param, char* val) {
	int tam = strlen(val);
	*param = (char*) malloc(sizeof(char) * (tam + 1));
	strcpy(*param, val);
}

int Vincular_Parametro(char** argv, int* i, char** param, int argc) {
	int res = NO_ERR;
	if ((*i + 1) >= argc) {
		res = ERR_SIN_PARAMETROS;
		fprintf(stderr, "%s", "ERROR");
	} else {
		++(*i);
		if (strcmp(argv[*i], "-") != 0) //{
			Init(param, argv[*i]);
			//++(*i);
		//} else ++(*i);
	}
	return res;
}


void Action(char* mode, int* i, char val) {
	*mode = val;
	++i;
}

void Operation(char** operation, int* i, char* val) {
	strcpy(*operation, val);
	++i;
}

int ProcesarEntrada(int argc, char** argv, char** dirEntrada, char** dirSalida,
		char* mode, char** operation) {
	int i = 1;
	int res = NO_ERR;
	while ((i < argc) && (res == NO_ERR)) {
		if (strcmp(argv[i], "-i") == 0)
			res = Vincular_Parametro(argv, &i, dirEntrada, argc);
		else if (strcmp(argv[i], "-o") == 0)
			res = Vincular_Parametro(argv, &i, dirSalida, argc);
		else if (strcmp(argv[i], "-h") == 0)
			res = Help_Option(&i);
		else if (strcmp(argv[i], "-V") == 0) {
			printf("%s", "Tp0 Computadoras");
			res = NO_PROCESAR;
		}
		else if (strcmp(argv[i], "-a") == 0)
			Action(mode, &i, 'a');
		else if (strcmp(argv[i], "decode") == 0) {
			Operation(operation, &i, "decode");
		}
		++i;
	}
	return res;
}

int ProcesarArchivo(char* dirEntrada, char* dirSalida, char mode, char* operation) {
	FILE* archEntrada;
	FILE* archSalida;
	int res = NO_ERR;

	if (dirEntrada == NULL)
		archEntrada = stdin;
	else {
		archEntrada = fopen(dirEntrada, "rb");
		if (archEntrada == NULL) {
			res = ERR_APERTURA_ARCHIVO;
			fprintf(stderr, "%s", "ERROR");
		}
	}

	if (res == NO_ERR) {
		if (dirSalida == NULL)
			archSalida = stdout;
		else {
			archSalida = fopen(dirSalida, "w");
			if (archSalida == NULL) {
				res = ERR_APERTURA_ARCHIVO;
				fprintf(stderr, "%s", "ERROR");
			}
		}
		if (res == NO_ERR) {
			if (mode == 'a') {
				if (strcmp(operation, "encode") == 0)
					binary_to_hexa(archEntrada, archSalida);
				else if (strcmp(operation, "decode") == 0)
					hexa_to_binary(archEntrada, archSalida);
			}

		}

			if (dirEntrada != NULL) {
				fclose(archEntrada);
				free(dirEntrada);
			}
			if (dirSalida != NULL) {
				fclose(archSalida);
				free(dirSalida);
			}

		}

	return res;
}


int main(int argc, char** argv) {
	char* dirEntrada = NULL;
	char* dirSalida = NULL;
	char* operation = NULL;
	char mode = 'a';
	Init(&operation, "encode");
	int res = ProcesarEntrada(argc, argv, &dirEntrada, &dirSalida, &mode, &operation);

	if (res == NO_ERR) {
		res = ProcesarArchivo(dirEntrada, dirSalida, mode, operation);
	}
	free(operation);
	return res;
}
